% -*- coding: utf-8 -*-
% ===========================
%   CONTENU DE LA PARTIE 2
% ===========================
% Mission / sujet du stage
%  - La partie le plus développée car reflet du travail effectué
%  - Objectifs du sujet et besoins de l’entreprise, votre méthodologie,
%    vos difficultés éventuelles, résultats éventuels
%    et intérêt final pour l’entreprise
%
% ===========================
% PRÉPARATIONS DE LA PARTIE 2
% ===========================
% Tenir un « journal de bord » dès les premiers jours et noter:
%  - tâches effectuées (pour une vue globale),
%  - obstacles rencontrés (pour les analyser),
%  - étapes franchies (pour progression du travail)
%
% ===========================
%     PLAN DE LA PARTIE 2
% ===========================
%
%

\chapter{Implantation de l'atmega128 dans le simulateur WSIM}
\section{Le contexte}

Le sujet proposé était de finir le l'implantation du microcontrôleur atmega128 
dans le simulateur WSIM.
 
Le travail avait déjà commencé pour la partie permettant l’exécution 
d’instructions simulées (simulation de l’unité arithmétique et logique).

Il fallait compléter la partie exécution des instructions ainsi que finir la 
partie concernant les périphériques dans le microcontrôleur comme les divers 
compteurs, horloge et gestion d’entrée/sortie.

Suite aux premières réunions, et après avoir lu une partie de la documentation 
présente sur le site web du projet, j’ai réussi à mieux comprendre les 
fonctionnalités de ce simulateur qui est codé en C.

WSIM simule non seulement un microcontrôleur, mais un système embarqué en sa 
totalité avec tous les appareils faisant partie du système comme des éventuelles 
radios pour la communication sans-fil.

Cette possibilité permet par exemple de simuler un nœud d’un réseau de capteurs 
sans-fils. De plus, en couplant WSIM avec le simulateur WSNet, on peut simuler 
un réseau de capteur intégral, avec des estimations de consommation en termes 
de cycle d’horloge et d’énergie précises.

C’est cette fonctionnalité même qui a motivé la création de ce projet. Dans un 
premier temps, les plateformes de capteurs sans-fils à base du microcontrôleur 
TI MSP430 ont été implantées dans le simulateur, puis ceux à base de 
l’atmega128.

D’où l’intérêt de rajouter la simulation du microcontrôleur AVR atmega128.

\section{La démarche et le travail accomplis}

\subsection{Les défits}
Durant mon cursus en Licence on a été amené à créer divers petits projets dans 
divers langages de programmation, mais on n’a jamais été amené à travailler sur 
des projets développés par d’autres.

En plus, en navigant un peu dans le code source du projet, je me suis rendu 
compte que des manipulations de bits sont faites sur des types de données qu’on 
n’a pas l’habitude de manipuler, comme les décalages de bits, l’utilisation des 
bitsfield et autre.

Ceci dit, passons à la partie suivante, où je vous explique mon approche pour 
surmonter ces difficultés, et d’avancer dans le projet.

Les notions de programmation requises ont été complétées grâce à un document 
trouvé sur internet (voir annexe \ref{annexe:bithacks}). Ce document explique 
avec une approche plus pratique que théorique comment effectuer des 
manipulations de bits basiques, avec les opérations binaires disponibles en C.

Pour pouvoir comprendre le code source, et pouvoir travailler sur le projet 
assez rapidement, l’outil de mon choix est cscope. Pour en citer les quelques 
fonctionnalités les plus exploités :
\begin{itemize}
	\item trouver un symbole C dans un code source
	\item trouver les fichiers où on appelle une certaine fonction
	\item trouver les fonctions appelées dans une certaine fonction
\end{itemize}
~~\\
Ce qui m’a conduit à choisir l’IDE codelite, pour les raisons suivantes :
\begin{itemize}
	\item intégration des outils nécessaires : cscope, svn, et gdb
	\item utilisation simple
	\item apprentissage rapide
\end{itemize}

\subsection{La démarche}
La méthode de travail mise en place pendant le stage a permis au projet 
d’avancer rapidement.

Deux fois par semaine, avec Antoine Fraboulet et Bernard Tourancheau nous 
faisions une réunion, au cours de laquelle nous évoquions l’état d’avancement 
du projet, une brève explication des étapes à venir, et les évolutions possibles 
de WSIM. Nous concluons toujours par 
le planning à tenir.

En fin de soirée, j'écrivais dans un dossier personnel un rapport de ma journée. 
Cette méthode m’a permis de bien structurer et rédiger mon rapport de stage 
lorsque je l'ai commencé.

Sur les huit étapes que j’ai prévu pour finir ma mission, j’en ai déjà réalisé 
cinq que je vais détailler ci-dessous :
\begin{center}
	\begin{tabular}{|c|l|c|}
	\hline
	 \# & Description de la tache                         & nbres de semaines \\
	\hline \hline
		1 & Étude de la documentation pour le développement & 1 \\ \hline
		2 & Étude des simulateurs d'atmega existants        & 2 \\ \hline
		3 & Étude du code source                            & 1 \\ \hline
		4 & Début du développement des instructions         & 1 \\ \hline
		5 & Fin du développement des instructions           & 1 \\ \hline
	\end{tabular}
	\label{tab:chrono-work}
\end{center}

\subsection{Étude de la documentation pour le développement}
J'ai étudié plusieurs documents en rapport avec WSIM, mais les trois documents 
que j'ai étudiés plus précisément sont :
\begin{itemize}
  \item Le document (voir annexe \ref{annexe:bithacks}) sur les opérations 
        binaires en C
  \item La documentation générée grâce à doxygen avec l’option des graphes 
        d'inclusions et des graphes d’appel de fonctions de manière à mieux 
        visualiser les relations entre les différents parties du code.
  \item La documentation de développement écrite par Antoine Fraboulet et 
        Loïc Lemaître qui détaille un peu le fonctionnement de 
        WSIM et explique comment faire pour rajouter des appareils et des 
        nouvelles plateformes.
\end{itemize}

\subsection{Étude des simulateurs d'atmega existant}
Dans mon travail de recherche documentaire, j’ai trouvé un rapport de stage de 
licence d’un étudiant \cite{navarfil2009b} qui porte sur le travail 
d'implantation de l'Atmel AT91 dans un simulateur, et le premier travail 
effectuer était de comparer les différents simulateurs existants pour en choisir 
un à porter.

J’ai donc décidé de prendre une approche similaire qui est de faire une étude 
de ce qui existe déjà pour pouvoir avancer plus rapidement.

Il existe un certain nombre de simulateur d’AVR atmega128 sur le marché, mais un 
premier trie a été fait pour ne garder que les simulateurs codés en C/C++ pour 
des raisons de performance et de compatibilité avec WSIM.

Durant cette partie de travail, j’ai étudié les deux simulateurs à licence 
libre compatible avec celui de WSIM :
\begin{enumerate}
	\item \shref{http://www.nongnu.org/simulavr/}{Simulavr}{simulavr}
	\begin{itemize}
	  \item Particularité
	  \begin{itemize}
	  	\item Langage de programmation : C++ / En orienté objet
	  	\item Interface graphique en TCL et python (non-testé)
	  \end{itemize}
		\item Avantages
		\begin{itemize}
			\item Simulation à cycle précis
			\item Facile à installer
			\item Interface pour débogage avec GDB (AVR-GDB)
			\item Capable de simuler un grand nombre de microcontrôleur atmega
		\end{itemize}
		\item Inconvénients
		\begin{itemize}
		  \item Le code n'est pas toujours lisible.
			\item Dans la boucle de simulation, durant l’étape de décodage des 
			      instructions, des allocations de mémoires et initialisations 
			      d’objets sont faites en plus de l’appel fonction : pénalisant la 
			      performance et la bonne gestion de la mémoire.
		\end{itemize}
	\end{itemize}
	\item \shref{http://avr.sourceforge.net/}{GNU AVR Simulator}{avrsim}
	\begin{itemize}
	  \item Particularité
	  \begin{itemize}
	  	\item Langage de programmation : C
	  	\item Interface graphique en OpenMotif
	  \end{itemize}
		\item Avantages
		\begin{itemize}
		  \item A part le choix de l'interface graphique, les choix vont 
		        généralement dans le sens de rendre l'execution rapide, tout en 
		        restant léger en mémoire.
		  \item Le code est propre, lisible, et facile à comprendre.
			\item Simulation a cycle précis
			\item Capable de simuler un grand nombre de microcontrôleur atmega
		\end{itemize}
		\item Inconvénients
		\begin{itemize}
		  \item Plus en développement depuis 2002
			\item Le fonctionnement est étroitement lié avec l’interface graphique qui 
			      est codé en motif (technologie obsolète).
			\item Ne prend que les fichiers en format IHEX (donc pas les fichiers elf)
			\item Pas d'interface GDB pour le débogage. Limité aux fonctionnalités 
			      fournies grâce à l'interface graphique.
			\item Ne compile pas avec les dernières versions du compilateur GCC sans
			      modifications du code.
		\end{itemize}
	\end{itemize}
\end{enumerate}

Ces simulateurs ne peuvent pas être réutilisés en tant que telle vu les 
différents choix de programmation des deux simulateurs.

Cependant, dans GNU AVR Simulator, la partie décodage des instructions est 
suffisamment clair pour mieux comprendre les datasheets du jeu d’instruction 
des AVR 8bits. En effet, cela me permettra donc de développer et finir assez 
rapidement la partie de l’unité arithmétique et logique.

Ceci dit, il faut bien étudier le code source de WSIM pour pouvoir avancer, 
d’où l’étape suivante.

\subsection{Étude du code source}
Il est temps de regarder le code source de WSIM. A part le dossier ‘doc’ que 
j’ai déjà exploité, les fichiers sources sont clairement organisés. Les dossiers 
portent des noms significatifs, permettant de trouver rapidement l’aspect du 
code qu’on cherche, dans mon cas, c’était le dossier ‘arch’ pour architecture.

\includegraphics[width = 0.2\linewidth]{arch.png}
Le dossier `common' contient la partie commune à tous les microcontrôleurs comme 
peut le suggérer le nom. On peut remarquer qu’un dossier pour chaque type de 
microcontrôleur est également présent. Dans le cadre de ce stage c’est dans le 
dossier atmega que je passerai le plus de temps pour continuer le développement 
de l’architecture.
~~\\

En plus de mon abus de cscope pour la compréhension du code source, Antoine 
Fraboulet a pris le temps à plusieurs reprises pour m’expliquer les 
fonctionnements interne du logiciel, et le fonctionnement des simulateurs en 
général.

Durant cette étude du code, j’ai constaté plusieurs caractéristiques :
\begin{itemize}
	\item Utilisation fréquente des macros pour deux grandes raisons
	\begin{enumerate}
		\item minimiser les appels de fonctions
		\item pouvoir générer à partir du même code un simulateur spécifique par 
		      plateforme implanté (système embarqué).
	\end{enumerate} 
	  \item Choix des types de données sont fait judicieusement de manière a 
	        minimisé l’impacte sur la mémoire : Cela permet par exemple 
	        d’augmenter la performance d’une simulation réseau sur WSNet avec des 
	        nœuds eux-mêmes simulé avec WSIM.
\end{itemize}

Après avoir bien compris la structure générale du code et le travail fait pour 
l’atmega128, il était temps de passer au développement.

\subsection{Développement des instructions}

La documentation officielle des instructions pour les AVR 8bit \cite{avr-isa, 
avr-doc}, n’avait pas une présentation pratique pour mon travail, donc j’ai dû 
transposer les informations dans un tableur (voir annexe \ref{annexe:tradisa}), 
me permettant non seulement de coder plus facilement, mais aussi de passer moins 
de temps pendant la révision du code.

Puis j’ai traduit ce jeu d’instruction en code C en utilisant les mêmes 
conventions que ceux utilisés dans le code source de WSIM.

A titre de comparaison, voir annexe \ref{annexe:comp} l'implantation de 
l'instruction ADC dans WSIM et les deux autres simulateurs étudiés.

Toutes les instructions des AVR 8-bits ont été implanté sauf ceux qui utilisent 
les vecteurs d’interruptions, ce qui veut dire qu’il sera facile de rajouter les 
autres AVR 8-bits à WSIM.

\subsection{Le travail qui reste}

Suite à cette étape, j’ai procédé à un nettoyage de code avant d’attaquer les 
étapes suivantes détaillé dans le tableau ci-dessous :
\begin{center}
	\begin{tabular}{|c|l|c|}
	\hline
		\# & Description de la tache                        & nbres de semaines \\
	\hline \hline
	   1 & Rajouter les timers                            & 1 \\ \hline
		 2 & Rajouter le vecteur d'interruption             & 1 \\ \hline
     3 & Planifier \& rajouter le reste des périphéries & 4 \\ \hline
	\end{tabular}
	\label{tab:chrono-future}
\end{center}

Le travail de d'implantation de l’atmega128 dans WSIM sera quasi-fini à la fin 
du mois de juillet.

Actuellement, avec le travail déjà accomplis, j’arrive à faire tourner des 
programmes simples qui font des calculs simples.

J’ai déjà commencé à réfléchir sur comment implanter les vecteurs d’interruptions 
et les timers. Je compte mettre en place un ensemble de petit programme pour
tester mon travail et suivre l'evolution du simulateur.

Une fois ces périphéries en place, je peux étudier les autres périphéries comme 
le port SPI et UART pour les communications série, le convertisseur 
analogue-numérique et les ports d’entrée/sortie.

